home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / C / Applications / Telnet 2.7b5 / source / tek / tekrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-01  |  12.2 KB  |  592 lines  |  [TEXT/CWIE]
  1. /*
  2. rgmac.c by Gaige B. Paulsen
  3.   spawned from rgp.c by Aaron Contorer for NCSA
  4. Copyright 1987, board of trustees, University of Illinois
  5.  
  6. Routines for Macintosh Window output.  
  7. */
  8.  
  9. #ifdef MPW
  10. #pragma segment TEKMAIN
  11. #endif
  12.  
  13.  
  14. #include "tekrgmac.proto.h"
  15. #include "maclook.proto.h"
  16. #include "vgtek.proto.h"
  17. #include "mydnr.proto.h"
  18. #include "rsinterf.proto.h"
  19. #include "netevent.proto.h"
  20. #include "rg0.proto.h"
  21. #include "rgmp.proto.h"
  22. #include "InternalEvents.h"
  23. #include "tekdefs.h"        /* NCSA: sb - all the TEK defines are now here */
  24.  
  25. //#define TEK_DEBUG1
  26. #ifdef    TEK_DEBUG1
  27.  
  28. #define    TEK_DEBUG_PRINT(x)    putln(x)
  29. char    TEK_DEBUG_STRING    [512];
  30. #else
  31. #define    TEK_DEBUG_PRINT(x)
  32. #endif
  33.  
  34. /*--------------------------------------------------------------------------*/
  35. /* Some variable definitions are needed before we give the code                */
  36. /*                                                                             */
  37. /*--------------------------------------------------------------------------*/
  38.  
  39. long    RGMlastclick;
  40. short    RGMcolor[]=
  41.     { 30,            /* black */
  42.       33,            /* white */
  43.       205,            /* red */
  44.       341,            /* green */
  45.       409,            /* blue */
  46.       273,            /* cyan */
  47.       137,            /* magenta */
  48.       69            /* yellow */
  49.       };
  50.  
  51. struct    RGMwindows *RGMwind[ MAXWIND ];
  52.  
  53. char    *RGMdevname(void)
  54. {
  55.     return("Macintosh Windows");
  56. }
  57.  
  58. short    RGMnewwin(void)
  59. {
  60.     short    i = 0;
  61.  
  62.     while ((i < MAXWIND) && (RGMwind[i] != nil)) i++;
  63.  
  64.     if (i >= MAXWIND) return(-1);
  65.  
  66.     RGMwind[i] = (struct RGMwindows *) myNewPtr(sizeof(struct RGMwindows));
  67.     if (RGMwind[i] == nil) {
  68.         return -1;
  69.         }
  70.  
  71.     RGMwind[i]->id = 'RGMW';
  72.  
  73.     RGMwind[i]->wind = GetNewWindow(256, NULL, kInFront);
  74.     if (RGMwind[i]->wind == 0L) {
  75.         DisposePtr((Ptr)RGMwind[i]);
  76.         RGMwind[i] = nil;
  77.         return -1;
  78.         }
  79.  
  80.     ((WindowPeek)RGMwind[i]->wind)->windowKind = WIN_TEK;
  81.     
  82.     RGMwind[i]->vg = -1;                /* BYU */
  83.     RGMwind[i]->vs = -1;                /* BYU */
  84.     RGMwind[i]->xorigin = 0;
  85.     RGMwind[i]->yorigin = 0;
  86.     RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  87.     RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  88.     RGMwind[i]->width   = 400;        /* BYU LSC - was 256 (size of old window resource */
  89.     RGMwind[i]->height  = 300;        /* BYU LSC - was 342 (size of old window resource */
  90.     RGMwind[i]->ingin   = 0;        /* BYU LSC */
  91.  
  92.     ValidRect(&RGMwind[i]->wind->portRect);  
  93.  
  94.     return(i);
  95. }
  96.  
  97. void    RGMinit(void)
  98. {
  99.     short    i;
  100.     for (i = 0; i < MAXWIND; i++)
  101.         RGMwind[i] = nil;
  102. }
  103.  
  104. short    RGMgin(short w)
  105. {
  106.     if (RGsetwind(w)) return(-1);
  107.  
  108.     setgraphcurs();
  109.     RGMwind[w]->ingin=1;
  110. }
  111.  
  112. short    RGMpencolor(short w, short color)
  113. {
  114.     if (RGsetwind(w) ) return(-1);
  115.     ForeColor((long) RGMcolor[color] );
  116. #ifdef    TEK_DEBUG_1
  117.     sprintf(TEK_DEBUG_STRING, "TEK: Setting pen color to %d", color);
  118.     putln(TEK_DEBUG_STRING);
  119. #endif
  120.  
  121. }
  122.  
  123. short    RGMclrscr(short w)
  124. {    
  125.     if (RGsetwind(w) ) return(-1);
  126.     PaintRect(&RGMwind[w]->wind->portRect);
  127.     TEK_DEBUG_PRINT("TEK: Clearing screen");                    
  128. }    
  129.  
  130. short    RGMclose(short w)
  131. {
  132.     if (RGsetwind(w) ) return(-1);
  133.  
  134.     DisposeWindow(RGMwind[w]->wind);
  135.     DisposePtr((Ptr)RGMwind[w]->name);
  136.     DisposePtr((Ptr)RGMwind[w]);
  137.     RGMwind[w] = nil;
  138. }
  139.  
  140. short    RGMpoint(short w, short x, short y)
  141. {
  142.     if (RGsetwind(w) ) return(-1);
  143.  
  144.     MoveTo(x,y);
  145.     LineTo(x,y);
  146. } 
  147.  
  148. short    RGMdrawline(short w, short x0, short y0, short x1, short y1)
  149. {
  150.     long    xl0, yl0, xl1, yl1;
  151.     
  152.     if (RGsetwind(w) )
  153.         return(-1);
  154.  
  155.     xl0 = ((long)x0 * RGMwind[w]->width) / INXMAX;
  156.     yl0 = (long)RGMwind[w]->height - (((long)y0 * RGMwind[w]->height) / INYMAX);
  157.     xl1 = ((long)x1 * RGMwind[w]->width) / INXMAX;
  158.     yl1 = (long)RGMwind[w]->height - (((long)y1 * RGMwind[w]->height) / INYMAX);
  159.  
  160.     MoveTo((short)xl0, (short)yl0);
  161.     LineTo((short)xl1, (short)yl1);
  162. }
  163.  
  164. void    RGMinfo(short w, short v, short a, short b, short c, short d)
  165. {
  166.     UNUSED_ARG(a)
  167.     UNUSED_ARG(b)
  168.     UNUSED_ARG(c)
  169.     UNUSED_ARG(d)
  170.     RGMwind[w]->vg=v;
  171. }
  172.  
  173. void    RGMpagedone(short w)
  174. {
  175.     UNUSED_ARG(w)
  176. }
  177.  
  178. void    RGMdataline(short w, short data, short count)
  179. {
  180.     UNUSED_ARG(w)
  181.     UNUSED_ARG(data)
  182.     UNUSED_ARG(count)
  183. }
  184.  
  185.  
  186. void    RGMcharmode(short w, short rotation, short size)
  187. {
  188.     UNUSED_ARG(w)
  189.     UNUSED_ARG(rotation)
  190.     UNUSED_ARG(size)
  191. }
  192.  
  193. void    RGMgmode(void)
  194. {}
  195.  
  196. void    RGMtmode(void)
  197. {}
  198.  
  199. void    RGMshowcur(void)
  200. {
  201. }
  202.  
  203. void    RGMlockcur(void)
  204. {
  205. }
  206.  
  207. void    RGMhidecur(void)
  208. {
  209. }
  210.  
  211. void    RGMbell(short w)
  212. {
  213.     UNUSED_ARG(w)
  214. }
  215.  
  216. void    RGMuncover(short w)
  217. {
  218.     UNUSED_ARG(w)
  219. }
  220.  
  221. short    RGMoutfunc(short (*f )())
  222. {
  223.     UNUSED_ARG(f)
  224.     return(0);    // Unused
  225. }
  226.  
  227. short    RGsetwind(short dnum)
  228. {
  229.     if (dnum<0 || dnum>=MAXWIND) return(-1);
  230.  
  231.     if (RGMwind[dnum] == nil) return -1;
  232.  
  233.     SetPort( RGMwind[dnum]->wind);
  234.     return(0);
  235. }
  236.  
  237. short    RGfindbyVG(short vg)
  238. {
  239.     short    i = 0;
  240.     
  241.     while (i < MAXWIND) {
  242.         if (RGMwind[i] != nil) {
  243.             if (RGMwind[i]->vg == vg)
  244.                 break;
  245.             }
  246.         i++;
  247.         }
  248.  
  249.     if (i >= MAXWIND) return(-1);
  250.     return(i);
  251. }
  252.  
  253. short    RGattach(short vg, short virt, char *name, short TEKtype)
  254. {
  255.     short            dnum;
  256.     unsigned long    time;
  257.     char            myname[256],ts[256];
  258.  
  259.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);
  260.  
  261.     RGMwind[dnum]->vs = virt;
  262.     RGMwind[dnum]->name = (unsigned char *) myNewPtr((long) 256);        /* BYU LSC */
  263.  
  264.     if (RGMwind[dnum]->name == 0L) return(-2);
  265.  
  266.     myname[0] = '•';
  267.     if (TEKtype)
  268.         strcpy(&myname[1], "[4105] ");
  269.     else
  270.         strcpy(&myname[1], "[4014] ");
  271.         
  272.     strncpy(&myname[strlen(myname)],name,120);
  273.  
  274.     GetDateTime(&time);
  275.     IUTimeString(time,FALSE,(StringPtr) ts);        /* BYU LSC - Put time in the temp string */
  276.     p2cstr((StringPtr)ts);                                            /* BYU LSC */
  277.  
  278.     strncat(myname,"  ",2);                /* BYU - was 4 - Space, please */
  279.     strncat(myname,ts,64);                /* BYU - Place the time string at the end */
  280.     strcpy((char *) RGMwind[dnum]->name,myname);    /* BYU LSC */
  281.  
  282.     if (RGMwind[dnum]->wind != (GrafPtr) 0) {    /* BYU LSC */
  283.         c2pstr(myname);                            /* BYU LSC */
  284.         SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);    /* BYU LSC */
  285.     }
  286.  
  287.     return(0);
  288. }
  289.  
  290.  
  291. short    RGdetach( short vg)
  292. {
  293.         short    dnum;            /* BYU */
  294.         char    myname[256];            /* BYU LSC */
  295.  
  296.     if ((dnum = RGfindbyVG(vg)) < 0) return(-1);        /* BYU */
  297.     if (dnum >= MAXWIND)  return(-1);                    /* BYU */
  298.  
  299.     if (RGMwind[dnum]->vs != -1) {                                     /* BYU */
  300.         if (RGMwind[dnum]->wind != (GrafPtr) 0) {                    /* BYU */
  301. #if 1
  302.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  303.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  304.             strncpy(myname, (char *) RGMwind[dnum]->name,256);    /* BYU LSC */
  305.             c2pstr(myname);                                        /* BYU LSC */
  306.             SetWTitle(RGMwind[dnum]->wind,(StringPtr)myname);                /* BYU LSC */
  307. #else
  308.             strncpy((char *) RGMwind[dnum]->name,                /* BYU LSC */
  309.                     (char *) &RGMwind[dnum]->name[1],255);        /* BYU LSC */
  310.             SetWTitle(RGMwind[dnum]->wind,RGMwind[dnum]->name);    /* BYU LSC */
  311. #endif
  312.         }                            /* BYU */
  313.     }                                /* BYU */
  314.     return(0);                        /* BYU */
  315. }
  316.  
  317. short    RGfindbywind( GrafPtr wind)
  318. {
  319.     short    i = 0;
  320.  
  321.     while (i < MAXWIND) {
  322.         if (RGMwind[i] != nil) {
  323.             if (RGMwind[i]->wind == wind)
  324.                 break;
  325.             }
  326.         i++;
  327.         }
  328.  
  329.     if (i >= MAXWIND) return(-1);
  330.     return(i);
  331. }
  332.  
  333. short    RGupdate( GrafPtr wind)
  334. {
  335.     short    i = 0,
  336.             done;
  337.  
  338.     if ((i = RGfindbywind(wind)) < 0)
  339.         return(-1);
  340.  
  341.     SetPort(wind);
  342.     BeginUpdate(wind);
  343.  
  344.     VGstopred(RGMwind[i]->vg);
  345.     VGpage(RGMwind[i]->vg);
  346.     done = VGpred(RGMwind[i]->vg,RGMwind[i]->vg);
  347.  
  348.     EndUpdate(wind);
  349.     if (!done)
  350.         netputevent(USERCLASS,RG_REDRAW,RGMwind[i]->vg,0);
  351.     return(done);
  352. }
  353.  
  354. short    RGsupdate( short i)
  355. {
  356.     short    rg;
  357.  
  358.     rg = RGfindbyVG(i);
  359.  
  360.     if (rg < 0) return(0);
  361.     SetPort(RGMwind[rg]->wind);
  362.     if (!VGpred(RGMwind[rg]->vg,RGMwind[rg]->vg))
  363.     {
  364.         netputevent(USERCLASS,RG_REDRAW,i,0);
  365.     }
  366.     else
  367.         return(1);
  368.     return(0);
  369. }
  370.  
  371. short    RGgetVG(GrafPtr wind)
  372. {
  373.     short    i;
  374.  
  375.     i = RGfindbywind(wind);
  376.  
  377.     return(RGMwind[i]->vg);
  378. }
  379.  
  380. short    RGgetdnum(GrafPtr wind)
  381. {
  382.     return(RGfindbywind(wind));
  383. }
  384.  
  385. short    RGgetVS(short dnum)
  386. {
  387.     return(RGMwind[dnum]->vs);
  388. }
  389.  
  390. short    inSplash(Point *p1, Point *p2)
  391. {
  392.     if ((p1->h - p2->h > 3) || (p2->h - p1->h > 3))
  393.         return(0);
  394.     if ((p1->v - p2->v > 3) || (p2->v - p1->v > 3))
  395.         return(0);
  396.  
  397.     return(1);
  398. }
  399.  
  400. void VidSync( void)
  401. {
  402.     long    a;
  403.     a = TickCount();            /* BYU LSC */
  404.     while (a == TickCount())
  405.         /* loop*/;    /* BYU LSC */
  406. }
  407.  
  408. void RGmousedown
  409.   (
  410.     GrafPtr wind,
  411.     Point *wherein
  412.   )
  413. {
  414.     unsigned long    lx,ly;        /* NCSA: SB */
  415.     char            thispaceforent[6];
  416.     short            i;
  417.     Point            where;
  418.     char            dum[32];
  419.  
  420.     where = *wherein;
  421.     if ((i = RGfindbywind(wind)) < 0)
  422.         return;
  423.  
  424.     if (!RGMwind[i]->ingin)
  425.     {
  426.     Point    anchor,current,last;
  427. #if 0                            /* BYU LSC - was "#ifndef MPW" */
  428.     long    TickCount();
  429. #endif MPW
  430.     long    tc;
  431.     short    x0,y0,x1,y1;
  432.     Rect    rect;
  433.     
  434.         SetPort(wind);
  435.     
  436.         last  = where;
  437.         current = where;
  438.         anchor = where;
  439.     
  440.         PenPat(PATTERN(qd.gray));    
  441.         PenMode(patXor);
  442.     
  443.         SetRect(&rect,0,0,0,0);
  444.     
  445.         while (StillDown())
  446.         {
  447.             GetMouse(¤t);
  448.             if (inSplash(¤t,&anchor)) continue;
  449.             tc = TickCount();
  450.             while(TickCount() == tc)
  451.                 /* loop */;
  452.             VidSync();
  453.             FrameRect(&rect);
  454.     
  455.             if (anchor.v < current.v)
  456.             {
  457.                 rect.top = anchor.v;
  458.                 rect.bottom = current.v;
  459.             }
  460.             else
  461.             {
  462.                 rect.top = current.v;
  463.                 rect.bottom = anchor.v;
  464.             }
  465.     
  466.             if (anchor.h < current.h)
  467.             {
  468.                 rect.left = anchor.h;
  469.                 rect.right = current.h;
  470.             }
  471.             else
  472.             {
  473.                 rect.right = anchor.h;
  474.                 rect.left = current.h;
  475.             }
  476.     
  477.             FrameRect(&rect);
  478.             last = current;
  479.         }
  480.     
  481.         FrameRect(&rect);
  482.  
  483.         PenPat(PATTERN(qd.black));    
  484.         PenMode(patCopy);
  485.  
  486.         if (!inSplash(&anchor,¤t))
  487.         {
  488.             x0 = (short) ((long) rect.left * RGMwind[i]->xscale / RGMwind[i]->width );
  489.             y0 = (short) (RGMwind[i]->yscale -
  490.                     (long) rect.top * RGMwind[i]->yscale / RGMwind[i]->height);
  491.             x1 = (short) ((long) rect.right * RGMwind[i]->xscale / RGMwind[i]->width);
  492.             y1 = (short) (RGMwind[i]->yscale -
  493.                     (long) rect.bottom * RGMwind[i]->yscale / RGMwind[i]->height);
  494.             x1 = (x1 < x0+2) ? x0 + 4 : x1;
  495.             y0 = (y0 < y1+2) ? y1 + 4 : y0;
  496.  
  497.             VGzoom( i,
  498.                     x0 + RGMwind[i]->xorigin,
  499.                     y1 + RGMwind[i]->yorigin,
  500.                     x1 + RGMwind[i]->xorigin,
  501.                     y0 + RGMwind[i]->yorigin);
  502.  
  503.             VGpage(RGMwind[i]->vg);
  504.  
  505.             RGMwind[i]->xscale  = x1 - x0;
  506.             RGMwind[i]->yscale  = y0 - y1;
  507.             RGMwind[i]->xorigin = x0 + RGMwind[i]->xorigin;
  508.             RGMwind[i]->yorigin = y1 + RGMwind[i]->yorigin;
  509.  
  510.             while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  511.                 Stask();
  512.             RGMlastclick = 0L;
  513.         }
  514.         else
  515.         {
  516.             if (RGMlastclick && ((RGMlastclick + GetDblTime()) > TickCount()))
  517.             {
  518.                 RGMwind[i]->xscale  = WINXMAX;    /* BYU LSC - need the "W" here */
  519.                 RGMwind[i]->yscale  = WINYMAX;    /* BYU LSC - need the "W" here */
  520.                 RGMwind[i]->xorigin = 0;
  521.                 RGMwind[i]->yorigin = 0;
  522.  
  523.                 VGzoom(i,0,0,WINXMAX-1,WINYMAX-1);    /* BYU LSC - need the "W" here */
  524.                 VGpage( RGMwind[i]->vg);
  525.                 while(!VGpred(RGMwind[i]->vg,RGMwind[i]->vg))
  526.                     Stask();
  527.                 RGMlastclick = 0L;
  528.             }
  529.             else RGMlastclick = TickCount();
  530.         }
  531.         return;
  532.     
  533.     }
  534.     
  535.     /* NCSA: SB */
  536.     /* NCSA: SB - These computations are being truncated and turned into signed ints. */
  537.     /* NCSA: SB - Just make sure everything is cast correctly, and were fine */
  538.     
  539.     lx = ((unsigned long)RGMwind[i]->xscale * (unsigned long)where.h)     /* NCSA: SB */
  540.             / (unsigned long)RGMwind[i]->width;                             /* NCSA: SB */
  541.     ly = (unsigned long)RGMwind[i]->yscale -                             /* NCSA: SB */
  542.         ((unsigned long)RGMwind[i]->yscale * (unsigned long)where.v) / (unsigned long)RGMwind[i]->height; /* NCSA: SB */
  543.  
  544.     VGgindata(RGMwind[i]->vg,(unsigned short) lx,(unsigned short)ly,' ',thispaceforent);    /* NCSA: SB */
  545.  
  546. #if 0                                                    /* BYU LSC - not needed */
  547. sprintf(dum,"GIN i: %d, vs: %d\015",i,RGMwind[i]->vs);    /* BYU 2.4.18 - changed \n to \015 */
  548. putln(dum);
  549. #endif                                                    /* BYU LSC - not needed */
  550.  
  551.     RSsendstring(RGMwind[i]->vs,thispaceforent,5);
  552.     sprintf(dum," \r\n");
  553.     RSsendstring(RGMwind[i]->vs,dum,3);
  554.     
  555.  
  556.     /*    RGMwind[i]->ingin = 0; */
  557.     unsetgraphcurs();
  558.     RGMlastclick = TickCount();
  559. }
  560.  
  561.  
  562. /*--------------------------------------------------------------------------*/
  563. /* NCSA: SB - RGMgrowme                                                        */
  564. /* This allows the TEK window to be grown like any other real window.        */
  565. /* The grow box is not shown on the screen, but it acts accordingly     - SMB    */
  566. /*--------------------------------------------------------------------------*/
  567. void    RGMgrowme(short myRGMnum,GrafPtr window, long *where, short modifiers)
  568. {
  569.     UNUSED_ARG(modifiers)
  570.     long size;
  571.     Rect SizRect;
  572.  
  573.     SetRect(&SizRect, 50, 50, 1500, 1500);            /* NCSA: SB - max size - arbitrary */
  574.  
  575.     if (where)
  576.     {        
  577.         size = GrowWindow(window, *(Point *) where, &SizRect);    
  578.         if (size != 0L)
  579.             {
  580.             SizeWindow(window, size & 0xffff, (size >> 16) & 0xffff, FALSE);
  581.             RGMwind[myRGMnum]->width   = window->portRect.right - window->portRect.left;        
  582.             RGMwind[myRGMnum]->height  = window->portRect.bottom - window->portRect.top;         
  583.             VGpage(RGMwind[myRGMnum]->vg);
  584.             InvalRect(&window->portRect);
  585.             RGupdate(window);
  586.             }
  587.         else
  588.             return;                            /* user skipped growing */
  589.     }
  590. }
  591.  
  592.